`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.

`Into<*Id>` is often entirely unnecessary, and at worst hides the type of
the Id with hard-coded Ids. This fixes this by just using the Id type
itself, which also helps with monomorphisation bloat.

I also removed `AsRef<str>`, as this can just be `&str` without
requiring a generic and without requiring a call to as_ref in the
function, while also not accidentally taking ownership of a `String`
passed in misleadingly.